YES 1.27 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/empty.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule Main
  ((scanr1 :: (a  ->  a  ->  a ->  [a ->  [a]) :: (a  ->  a  ->  a ->  [a ->  [a])

module Main where
  import qualified Prelude



Lambda Reductions:
The following Lambda expression
\qsqs

is transformed to
qs0 qs = qs

The following Lambda expression
\(q : _)→q

is transformed to
q1 (q : _) = q



↳ HASKELL
  ↳ LR
HASKELL
      ↳ BR

mainModule Main
  ((scanr1 :: (a  ->  a  ->  a ->  [a ->  [a]) :: (a  ->  a  ->  a ->  [a ->  [a])

module Main where
  import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule Main
  ((scanr1 :: (a  ->  a  ->  a ->  [a ->  [a]) :: (a  ->  a  ->  a ->  [a ->  [a])

module Main where
  import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule Main
  ((scanr1 :: (a  ->  a  ->  a ->  [a ->  [a]) :: (a  ->  a  ->  a ->  [a ->  [a])

module Main where
  import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
f x q : qs
where 
q  = q1 vu41
q1 (q : vv) = q
qs  = qs0 vu41
qs0 qs = qs
vu41  = scanr1 f xs

are unpacked to the following functions on top level
scanr1Q vy vz = scanr1Q1 vy vz (scanr1Vu41 vy vz)

scanr1Qs0 vy vz qs = qs

scanr1Vu41 vy vz = scanr1 vy vz

scanr1Q1 vy vz (q : vv) = q

scanr1Qs vy vz = scanr1Qs0 vy vz (scanr1Vu41 vy vz)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ Narrow

mainModule Main
  (scanr1 :: (a  ->  a  ->  a ->  [a ->  [a])

module Main where
  import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
QDP
                      ↳ RuleRemovalProof

Q DP problem:
The TRS P consists of the following rules:

new_scanr1(wu3, :(wu40, :(wu410, wu411)), ba) → new_scanr1(wu3, :(wu410, wu411), ba)
new_scanr1Vu41(wu3, wu410, wu411, ba) → new_scanr1(wu3, :(wu410, wu411), ba)
new_scanr1(wu3, :(wu40, :(wu410, wu411)), ba) → new_scanr1Vu41(wu3, wu410, wu411, ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the rule removal processor [15] with the following polynomial ordering [25], at least one Dependency Pair or term rewrite system rule of this QDP problem can be strictly oriented.
Strictly oriented dependency pairs:

new_scanr1(wu3, :(wu40, :(wu410, wu411)), ba) → new_scanr1(wu3, :(wu410, wu411), ba)
new_scanr1(wu3, :(wu40, :(wu410, wu411)), ba) → new_scanr1Vu41(wu3, wu410, wu411, ba)


Used ordering: POLO with Polynomial interpretation [25]:

POL(:(x1, x2)) = 2 + 2·x1 + x2   
POL(new_scanr1(x1, x2, x3)) = x1 + x2 + x3   
POL(new_scanr1Vu41(x1, x2, x3, x4)) = 2 + x1 + 2·x2 + x3 + x4   



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ QDP
                      ↳ RuleRemovalProof
QDP
                          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

new_scanr1Vu41(wu3, wu410, wu411, ba) → new_scanr1(wu3, :(wu410, wu411), ba)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 0 SCCs with 1 less node.